const path = require('path')
const fs = require('fs').promises
const express = require('express')
const router = express.Router()
const { PrismaClient } = require('@prisma/client')
const prisma = new PrismaClient()
const response = require('../utils/response')
const verifyToken = require('../middleware/auth')

/**
 * 创建商品
 * @route POST /storeItem
 * @param {object} req.body - 商品信息
 * @returns {object} 创建的商品信息
 */
router.post('/', verifyToken, async (req, res) => {
  try {
    // 提取必填字段
    let {
      itemCode,
      name,
      category = '',
      unit,
      quantity = 0,
      minQuantity = 0,
      maxQuantity = 0,
      price,
      status = true,
      image = null,
      remark = null,
    } = req.body

    // itemCode = Math.random().toString().slice(2, 12)

    // 验证必填字段
    if (
      !itemCode ||
      !name ||
      !unit ||
      quantity === undefined ||
      price === undefined
    ) {
      return res.json(response(false, '缺少必填字段', null, 400))
    }

    // 根据schema定义的字段过滤请求数据
    const allowedFields = {
      itemCode,
      name,
      category,
      unit,
      quantity,
      minQuantity,
      maxQuantity,
      price,
      status,
      image,
      remark: req.body.remark || null,
    }

    // 检查是否存在未定义的字段
    const extraFields = Object.keys(req.body).filter(
      (key) => !(key in allowedFields)
    )
    if (extraFields.length > 0) {
      return res.json(
        response(
          false,
          `包含未定义的字段: ${extraFields.join(', ')}`,
          null,
          400
        )
      )
    }

    // 检查商品编码是否已存在
    const existingItem = await prisma.StoreItem.findUnique({
      where: {
        itemCode: allowedFields.itemCode,
      },
    })

    if (existingItem) {
      return res.json(response(false, '商品编码已存在', null, 400))
    }

    // 创建商品
    const storeItem = await prisma.StoreItem.create({
      data: allowedFields,
    })
    res.json(response(true, '创建成功', storeItem, 200)) // 创建成功返回200
  } catch (error) {
    res.json(response(false, error.message, null, 400)) // 创建失败返回400
  }
})

/**
 * 获取所有商品
 * @route GET /storeItem
 * @returns {Array} 商品列表
 */
router.get('/', verifyToken, async (req, res) => {
  try {
    const page = parseInt(req.query.page) || 1
    const pageSize = parseInt(req.query.pageSize) || 10
    const skip = (page - 1) * pageSize

    let storeItems = []
    const itemCode = req.query.itemCode
    const filter = itemCode ? { where: { itemCode } } : {}

    if (filter.where) {
      storeItems = await prisma.StoreItem.findMany({
        where: filter.where,
        skip,
        take: pageSize,
        orderBy: {
          id: 'desc',
        },
      })
    } else {
      storeItems = await prisma.StoreItem.findMany({
        skip,
        take: pageSize,
        orderBy: {
          id: 'desc',
        },
      })
    }
    const total = await prisma.StoreItem.count(filter)

    res.json(
      response(
        true,
        '查询成功',
        {
          list: storeItems,
          pagination: {
            current: page,
            pageSize,
            total,
          },
        },
        200
      )
    ) // 查询成功返回200
  } catch (error) {
    res.json(response(false, error.message, null, 500)) // 查询失败返回500
  }
})

/**
 * 根据itemCode获取商品
 * @route GET /storeItem/itemCode
 * @param {string} req.query.itemCode - 商品编码
 * @returns {object} 商品信息
 */
router.get('/itemCode', verifyToken, async (req, res) => {
  try {
    const itemCode = req.query.itemCode
    if (!itemCode) {
      return res.json(response(false, '缺少itemCode参数', null, 400)) // 缺少参数返回400
    }

    const storeItem = await prisma.StoreItem.findUnique({
      where: {
        itemCode: itemCode,
      },
    })

    if (!storeItem) {
      return res.json(response(false, '商品不存在', null, 404)) // 未找到返回404
    }

    res.json(response(true, '查询成功', storeItem, 200)) // 查询成功返回200
  } catch (error) {
    res.json(response(false, error.message, null, 500)) // 查询失败返回500
  }
})

/**
 * 查询库存告警
 * @route GET /storeItem/alert
 * @returns {object} 库存告警商品列表
 */
router.get('/lowStock', verifyToken, async (req, res) => {
  try {
    const lowStockItems = await prisma.StoreItem.findMany({
      where: {
        quantity: {
          lt: 6,
        },
      },
    })
    res.json(response(true, '查询成功', lowStockItems, 200)) // 查询成功返回200
  } catch (error) {
    res.json(response(false, error.message, null, 400)) // 查询失败返回400
  }
})

/**
 * 查询所有商品
 * @route GET /storeItem
 * @returns {Array} 商品列表
 */
router.get('/resetItem', verifyToken, async (req, res) => {
  try {
    const page = parseInt(req.query.page) || 1
    const pageSize = parseInt(req.query.pageSize) || 10
    const skip = (page - 1) * pageSize

    const storeItems = await prisma.StoreItem.findMany({
      skip,
      take: pageSize,
      orderBy: {
        id: 'desc',
      },
    })

    storeItems.forEach(async (item) => {
      item.image = item.image.replace(
        'http://139.9.128.158:3000/uploads/',
        'http://139.9.128.158:3000/'
      )
      await prisma.StoreItem.update({
        where: { id: item.id },
        data: { image: item.image },
      })
    })

    const total = await prisma.StoreItem.count()

    res.json(
      response(
        true,
        '查询成功',
        {
          list: storeItems,
          pagination: {
            current: page,
            pageSize,
            total,
          },
        },
        200
      )
    ) // 查询成功返回200
  } catch (error) {
    res.json(response(false, error.message, null, 500)) // 查询失败返回500
  }
})

/**
 * 查询商品记录
 * @route GET /storeItem/records
 * @param {string} req.query.startDate - 起始时间
 * @param {string} req.query.endDate - 结束时间
 * @returns {Array} 商品记录列表
 */
router.get('/records', verifyToken, async (req, res) => {
  const { startDate, endDate } = req.query

  if (!startDate || !endDate) {
    return res.json(response(false, '缺少起始时间或结束时间', null, 400)) // 返回400
  }

  try {
    const storeItems = await prisma.StoreItemLog.findMany({
      where: {
        createdAt: {
          gte: new Date(Number(startDate)),
          lte: new Date(Number(endDate)),
        },
      },
      orderBy: {
        createdAt: 'desc',
      },
    })

    res.json(response(true, '查询成功', storeItems, 200)) // 查询成功返回200
  } catch (error) {
    res.json(response(false, error.message, null, 500)) // 查询失败返回500
  }
})

/**
 * 删除商品记录
 * @route DELETE /storeItem/records/:id
 * @param {number} req.params.id - 商品记录ID
 * @returns {object} 删除的商品记录信息
 */
router.delete('/records/:id', verifyToken, async (req, res) => {
  try {
    const existingRecord = await prisma.StoreItemLog.findUnique({
      where: {
        id: parseInt(req.params.id),
      },
    });

    if (!existingRecord) {
      return res.json(response(false, '商品记录不存在', null, 404));
    }

    const deletedRecord = await prisma.StoreItemLog.delete({
      where: {
        id: parseInt(req.params.id),
      },
    });

    res.json(response(true, '删除成功', deletedRecord, 200)); // 删除成功返回200
  } catch (error) {
    res.json(response(false, error.message, null, 500)); // 删除失败返回500
  }
})


/**
 * 根据ID获取商品
 * @route GET /storeItem/:id
 * @param {number} req.params.id - 商品ID
 * @returns {object} 商品信息
 */
router.get('/:id', verifyToken, async (req, res) => {
  try {
    const storeItem = await prisma.StoreItem.findUnique({
      where: {
        id: parseInt(req.params.id),
      },
    })
    if (!storeItem) {
      return res.json(response(false, '商品不存在', null, 404)) // 未找到返回404
    }
    res.json(response(true, '查询成功', storeItem, 200)) // 查询成功返回200
  } catch (error) {
    res.json(response(false, error.message, null, 500)) // 查询失败返回500
  }
})

/**
 * 更新商品信息
 * @route PUT /storeItem/:id
 * @param {number} req.params.id - 商品ID
 * @param {object} req.body - 更新的商品信息
 * @returns {object} 更新后的商品信息
 */
router.put('/:id', verifyToken, async (req, res) => {
  try {
    const { type, typeValue, ...updatedData } = req.body // 排除 type 和 typeValue 字段
    const storeItem = await prisma.StoreItem.update({
      where: {
        id: parseInt(req.params.id),
      },
      data: updatedData,
    })
    if (type === 'quantity') {
      await prisma.StoreItemLog.create({
        data: {
          name: storeItem.name,
          image: storeItem.image,
          itemCode: storeItem.itemCode,
          price: storeItem.price,
          category: storeItem.category,
          quantity: storeItem.quantity,
          type: typeValue,
        },
      })
    }
    res.json(response(true, '更新成功', storeItem, 200)) // 更新成功返回200
  } catch (error) {
    res.json(response(false, error.message, null, 400)) // 更新失败返回400
  }
})

/**
 * 删除商品
 * @route DELETE /storeItem/:id
 * @param {number} req.params.id - 商品ID
 * @returns {object} 删除的商品信息
 */
router.delete('/:id', verifyToken, async (req, res) => {
  try {
    // 先查询商品是否存在
    const existingItem = await prisma.StoreItem.findUnique({
      where: {
        id: parseInt(req.params.id),
      },
    })

    if (!existingItem) {
      return res.json(response(false, '商品不存在', null, 404))
    }
    // 如果商品有图片,则删除图片文件
    if (existingItem.image) {
      try {
        let filePath = existingItem.image.split('/').pop() // 获取URL最后一个斜杠后的文件名
        const imagePath = path.join(__dirname, '..', 'uploads', filePath)
        await fs.unlink(imagePath)
      } catch (error) {
        console.error('删除商品图片失败:', error)
        // 继续执行删除商品操作,不中断流程
      }
    }
    const storeItem = await prisma.StoreItem.delete({
      where: {
        id: parseInt(req.params.id),
      },
    })
    res.json(response(true, '删除成功', storeItem, 200)) // 删除成功返回200
  } catch (error) {
    res.json(response(false, error.message, null, 400)) // 删除失败返回400
  }
})

module.exports = router
